{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision.datasets import ImageFolder\n",
    "import torch.utils.data as Data\n",
    "import torchvision.transforms as transforms\n",
    "import time # 导入模块\n",
    "import torch.nn as nn\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AlexNet(nn.Module):\n",
    "    def __init__(self, num_classes=3):\n",
    "        super(AlexNet, self).__init__()\n",
    "        self.block1 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=96, kernel_size=11, stride=4, padding=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "        )\n",
    "        self.block2 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=96, out_channels=256, kernel_size=5, stride=1, padding=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "        )\n",
    "        self.block3 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=256, out_channels=384, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "        self.block4 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=384, out_channels=384, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "        self.block5 = nn.Sequential(\n",
    "            nn.Dropout(p=0.5),\n",
    "            nn.Linear(in_features=384*3*3, out_features=4096),\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "        self.block6 = nn.Sequential(\n",
    "            nn.Dropout(p=0.5),\n",
    "            nn.Linear(in_features=4096, out_features=4096),\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "        self.block7 = nn.Sequential(\n",
    "            nn.Linear(in_features=4096, out_features=num_classes)\n",
    "        )\n",
    "    def forward(self,x):\n",
    "        x = self.block1(x)\n",
    "        x = self.block2(x)\n",
    "        x = self.block3(x)\n",
    "        x = self.block4(x)\n",
    "#         print(x.size())\n",
    "        x = x.view(x.size(0), 384*3*3)\n",
    "        x = self.block5(x)\n",
    "        x = self.block6(x)\n",
    "        x = self.block7(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "962\n",
      "340\n",
      "torch.Size([3, 64, 64])\n",
      "{'bus': 0, 'car': 1, 'truck': 2}\n",
      "torch.Size([3, 64, 64])\n",
      "{'bus': 0, 'car': 1, 'truck': 2}\n"
     ]
    }
   ],
   "source": [
    "data_transform = transforms.Compose([\n",
    "    transforms.Resize((64,64)),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=[0.5,0.5,0.5], std=[0.5, 0.5, 0.5])\n",
    "])\n",
    "BATCH_SIZE = 128\n",
    "train_dataset = ImageFolder(\"vehicle_dataset_new/training_dataset\",transform = data_transform)\n",
    "train_loader = Data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "\n",
    "test_dataset = ImageFolder(\"vehicle_dataset_new/test_dataset\",transform = data_transform)\n",
    "test_loader = Data.DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "print(len(train_dataset))\n",
    "print(len(test_dataset))\n",
    "print(train_dataset[0][0].size())\n",
    "print(train_dataset.class_to_idx)\n",
    "print(test_dataset[0][0].size())\n",
    "print(test_dataset.class_to_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_epoch(net, data_loader, device):\n",
    "    net.train()\n",
    "    train_batch_num = len(data_loader)\n",
    "    total_loss = 0\n",
    "    correct = 0\n",
    "    sample_num = 0\n",
    "\n",
    "    for batch_idx, (data, target) in enumerate(data_loader):\n",
    "        # print(data)\n",
    "        # print(target)\n",
    "        data = data.to(device).float()\n",
    "        target = target.to(device).long()\n",
    "        optimizer.zero_grad()\n",
    "        output = net(data)\n",
    "        loss = criterion(output, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total_loss += loss.item()\n",
    "        prediction = torch.argmax(output, 1)\n",
    "#         print(\"output\", output)\n",
    "#         print(\"prediction\", prediction)\n",
    "#         print(\"target\", target)\n",
    "        correct += (prediction == target).sum().item()\n",
    "        sample_num += len(prediction)\n",
    "    loss = total_loss / train_batch_num\n",
    "    acc = correct / sample_num\n",
    "    return loss, acc\n",
    "\n",
    "def test_epoch(net, data_loader, device):\n",
    "    net.eval()\n",
    "    test_batch_num = len(data_loader)\n",
    "    total_loss = 0\n",
    "    correct = 0\n",
    "    sample_num = 0\n",
    "    with torch.no_grad():\n",
    "        for batch_idx, (data, target) in enumerate(data_loader):\n",
    "            data = data.to(device).float()\n",
    "            target = target.to(device).long()\n",
    "            output = net(data)\n",
    "            loss = criterion(output, target)\n",
    "            total_loss += loss.item()\n",
    "            prediction = torch.argmax(output, 1)\n",
    "            correct += (prediction == target).sum().item()\n",
    "            sample_num += len(prediction)\n",
    "    loss = total_loss / test_batch_num\n",
    "    acc = correct / sample_num\n",
    "    return loss, acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练------0-------------\n",
      "epoch:0\t train_loss:1.3050 \ttrain_acc: 0.5499 \ttest_loss: 0.9503 \t test_acc: 0.5735 \t training_time: 11.53\n",
      "开始训练------1-------------\n",
      "epoch:1\t train_loss:0.9949 \ttrain_acc: 0.5499 \ttest_loss: 0.8953 \t test_acc: 0.5735 \t training_time: 11.05\n",
      "开始训练------2-------------\n",
      "epoch:2\t train_loss:0.8330 \ttrain_acc: 0.5884 \ttest_loss: 0.5996 \t test_acc: 0.7765 \t training_time: 15.08\n",
      "开始训练------3-------------\n",
      "epoch:3\t train_loss:0.5466 \ttrain_acc: 0.7713 \ttest_loss: 0.4749 \t test_acc: 0.7706 \t training_time: 11.08\n",
      "开始训练------4-------------\n",
      "epoch:4\t train_loss:0.4066 \ttrain_acc: 0.8191 \ttest_loss: 0.4079 \t test_acc: 0.8471 \t training_time: 11.19\n",
      "开始训练------5-------------\n",
      "epoch:5\t train_loss:0.3406 \ttrain_acc: 0.8701 \ttest_loss: 0.4704 \t test_acc: 0.8029 \t training_time: 11.40\n",
      "开始训练------6-------------\n",
      "epoch:6\t train_loss:0.3626 \ttrain_acc: 0.8472 \ttest_loss: 0.3351 \t test_acc: 0.8794 \t training_time: 10.98\n",
      "开始训练------7-------------\n",
      "epoch:7\t train_loss:0.2805 \ttrain_acc: 0.8929 \ttest_loss: 0.2832 \t test_acc: 0.8794 \t training_time: 11.03\n",
      "开始训练------8-------------\n",
      "epoch:8\t train_loss:0.2232 \ttrain_acc: 0.9179 \ttest_loss: 0.2470 \t test_acc: 0.9029 \t training_time: 11.02\n",
      "开始训练------9-------------\n",
      "epoch:9\t train_loss:0.1959 \ttrain_acc: 0.9304 \ttest_loss: 0.2578 \t test_acc: 0.8882 \t training_time: 15.84\n",
      "开始训练------10-------------\n",
      "epoch:10\t train_loss:0.1873 \ttrain_acc: 0.9314 \ttest_loss: 0.3106 \t test_acc: 0.8735 \t training_time: 12.92\n",
      "开始训练------11-------------\n",
      "epoch:11\t train_loss:0.2371 \ttrain_acc: 0.9210 \ttest_loss: 0.2821 \t test_acc: 0.8735 \t training_time: 13.26\n",
      "开始训练------12-------------\n",
      "epoch:12\t train_loss:0.1897 \ttrain_acc: 0.9272 \ttest_loss: 0.2279 \t test_acc: 0.9059 \t training_time: 11.14\n",
      "开始训练------13-------------\n",
      "epoch:13\t train_loss:0.1406 \ttrain_acc: 0.9501 \ttest_loss: 0.2171 \t test_acc: 0.9176 \t training_time: 10.41\n",
      "开始训练------14-------------\n",
      "epoch:14\t train_loss:0.1204 \ttrain_acc: 0.9543 \ttest_loss: 0.3334 \t test_acc: 0.8971 \t training_time: 11.18\n",
      "开始训练------15-------------\n",
      "epoch:15\t train_loss:0.1328 \ttrain_acc: 0.9563 \ttest_loss: 0.3269 \t test_acc: 0.9118 \t training_time: 12.39\n",
      "开始训练------16-------------\n",
      "epoch:16\t train_loss:0.1476 \ttrain_acc: 0.9511 \ttest_loss: 0.3107 \t test_acc: 0.8588 \t training_time: 14.11\n",
      "开始训练------17-------------\n",
      "epoch:17\t train_loss:0.1163 \ttrain_acc: 0.9657 \ttest_loss: 0.2516 \t test_acc: 0.9147 \t training_time: 11.52\n",
      "开始训练------18-------------\n",
      "epoch:18\t train_loss:0.0921 \ttrain_acc: 0.9647 \ttest_loss: 0.2770 \t test_acc: 0.9059 \t training_time: 14.65\n",
      "开始训练------19-------------\n",
      "epoch:19\t train_loss:0.1289 \ttrain_acc: 0.9459 \ttest_loss: 0.2295 \t test_acc: 0.9353 \t training_time: 10.85\n"
     ]
    }
   ],
   "source": [
    "num_classes = 3\n",
    "epochs = 20\n",
    "lr = 0.001\n",
    "device = torch.device('cpu')\n",
    "# device = torch.device('cuda')\n",
    "\n",
    "net = AlexNet().to(device)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr = lr)\n",
    "\n",
    "train_loss_list = []\n",
    "train_acc_list = []\n",
    "test_loss_list = []\n",
    "test_acc_list = []\n",
    "training_time_list = []\n",
    "for epoch in range(epochs):\n",
    "    print(\"开始训练------\" + str(epoch) + \"-------------\")\n",
    "\n",
    "    start = time.time()  #开始时间\n",
    "    train_loss, train_acc = train_epoch(net, data_loader=train_loader, device=device)\n",
    "    end = time.time()  #结束时间\n",
    "    test_loss, test_acc = 0, 0\n",
    "    test_loss, test_acc  = test_epoch(net, data_loader=test_loader, device=device)\n",
    "    train_loss_list.append(train_loss)\n",
    "    train_acc_list.append(train_acc)\n",
    "    test_loss_list.append(test_loss)\n",
    "    test_acc_list.append(test_acc)\n",
    "    training_time_list.append(end - start)\n",
    "    print(f\"epoch:{epoch}\\t train_loss:{train_loss:.4f} \\t\"\n",
    "          f\"train_acc: {train_acc:.4f} \\t\"\n",
    "          f\"test_loss: {test_loss:.4f} \\t test_acc: {test_acc:.4f} \\t training_time: {end-start:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练------20-------------\n",
      "epoch:20\t train_loss:0.0929 \ttrain_acc: 0.9657 \ttest_loss: 0.4661 \t test_acc: 0.9118 \t training_time: 11.05\n",
      "开始训练------21-------------\n",
      "epoch:21\t train_loss:0.0879 \ttrain_acc: 0.9719 \ttest_loss: 0.2037 \t test_acc: 0.9118 \t training_time: 11.71\n",
      "开始训练------22-------------\n",
      "epoch:22\t train_loss:0.1033 \ttrain_acc: 0.9667 \ttest_loss: 0.2128 \t test_acc: 0.9265 \t training_time: 11.02\n",
      "开始训练------23-------------\n",
      "epoch:23\t train_loss:0.0712 \ttrain_acc: 0.9792 \ttest_loss: 0.1903 \t test_acc: 0.9206 \t training_time: 10.93\n",
      "开始训练------24-------------\n",
      "epoch:24\t train_loss:0.0695 \ttrain_acc: 0.9740 \ttest_loss: 0.2427 \t test_acc: 0.9235 \t training_time: 11.02\n",
      "开始训练------25-------------\n",
      "epoch:25\t train_loss:0.0480 \ttrain_acc: 0.9823 \ttest_loss: 0.3296 \t test_acc: 0.9029 \t training_time: 10.94\n",
      "开始训练------26-------------\n",
      "epoch:26\t train_loss:0.0674 \ttrain_acc: 0.9751 \ttest_loss: 0.2475 \t test_acc: 0.9324 \t training_time: 10.88\n",
      "开始训练------27-------------\n",
      "epoch:27\t train_loss:0.0430 \ttrain_acc: 0.9844 \ttest_loss: 0.3792 \t test_acc: 0.9176 \t training_time: 11.06\n",
      "开始训练------28-------------\n",
      "epoch:28\t train_loss:0.0444 \ttrain_acc: 0.9896 \ttest_loss: 0.2801 \t test_acc: 0.9265 \t training_time: 14.55\n",
      "开始训练------29-------------\n",
      "epoch:29\t train_loss:0.0296 \ttrain_acc: 0.9917 \ttest_loss: 0.2827 \t test_acc: 0.9265 \t training_time: 11.46\n",
      "开始训练------30-------------\n",
      "epoch:30\t train_loss:0.0489 \ttrain_acc: 0.9802 \ttest_loss: 0.2435 \t test_acc: 0.9206 \t training_time: 10.71\n",
      "开始训练------31-------------\n",
      "epoch:31\t train_loss:0.0422 \ttrain_acc: 0.9844 \ttest_loss: 0.3843 \t test_acc: 0.9176 \t training_time: 10.56\n",
      "开始训练------32-------------\n",
      "epoch:32\t train_loss:0.0342 \ttrain_acc: 0.9896 \ttest_loss: 0.3399 \t test_acc: 0.9235 \t training_time: 11.22\n",
      "开始训练------33-------------\n",
      "epoch:33\t train_loss:0.0339 \ttrain_acc: 0.9865 \ttest_loss: 0.4395 \t test_acc: 0.9235 \t training_time: 11.46\n",
      "开始训练------34-------------\n",
      "epoch:34\t train_loss:0.0593 \ttrain_acc: 0.9854 \ttest_loss: 0.2969 \t test_acc: 0.9235 \t training_time: 11.41\n",
      "开始训练------35-------------\n",
      "epoch:35\t train_loss:0.0471 \ttrain_acc: 0.9823 \ttest_loss: 0.3926 \t test_acc: 0.9000 \t training_time: 10.49\n",
      "开始训练------36-------------\n",
      "epoch:36\t train_loss:0.0835 \ttrain_acc: 0.9761 \ttest_loss: 0.4038 \t test_acc: 0.9294 \t training_time: 11.04\n",
      "开始训练------37-------------\n",
      "epoch:37\t train_loss:0.0520 \ttrain_acc: 0.9802 \ttest_loss: 0.3144 \t test_acc: 0.9029 \t training_time: 11.48\n",
      "开始训练------38-------------\n",
      "epoch:38\t train_loss:0.0814 \ttrain_acc: 0.9730 \ttest_loss: 0.2449 \t test_acc: 0.9206 \t training_time: 11.80\n",
      "开始训练------39-------------\n",
      "epoch:39\t train_loss:0.0663 \ttrain_acc: 0.9792 \ttest_loss: 0.1997 \t test_acc: 0.9265 \t training_time: 11.42\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(epochs):\n",
    "    print(\"开始训练------\" + str(20 + epoch) + \"-------------\")\n",
    "\n",
    "    start = time.time()  #开始时间\n",
    "    train_loss, train_acc = train_epoch(net, data_loader=train_loader, device=device)\n",
    "    end = time.time()  #结束时间\n",
    "    test_loss, test_acc = 0, 0\n",
    "    test_loss, test_acc  = test_epoch(net, data_loader=test_loader, device=device)\n",
    "    train_loss_list.append(train_loss)\n",
    "    train_acc_list.append(train_acc)\n",
    "    test_loss_list.append(test_loss)\n",
    "    test_acc_list.append(test_acc)\n",
    "    training_time_list.append(end - start)\n",
    "    print(f\"epoch:{20 + epoch}\\t train_loss:{train_loss:.4f} \\t\"\n",
    "          f\"train_acc: {train_acc:.4f} \\t\"\n",
    "          f\"test_loss: {test_loss:.4f} \\t test_acc: {test_acc:.4f} \\t training_time: {end-start:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "def plot(train_loss_list,label,title, subplot):\n",
    "    ax1 = plt.subplot(subplot)\n",
    "    plt.plot(list(range(len(train_loss_list))),train_loss_list, label=label)\n",
    "    ax1.set_title(title)\n",
    "    ax1.legend()\n",
    "#     plt.title(title)\n",
    "#     plt.legend()\n",
    "#     plt.show()\n",
    "plot(train_loss_list,\"train loss\",\"train loss\", 221)\n",
    "plot(test_loss_list,\"test loss\",\"test loss\", 222)\n",
    "plot(train_acc_list,\"train acc\",\"train acc\", 223)\n",
    "plot(test_acc_list,\"test acc\",\"test acc\", 224)\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}